home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / SERVPRIV.PAK / CSTRING.H < prev    next >
C/C++ Source or Header  |  1997-05-06  |  35KB  |  1,090 lines
  1. //----------------------------------------------------------------------------
  2. // Borland Class Library
  3. // (C) Copyright 1993, 1997 by Borland International, All Rights Reserved
  4. //
  5. //   Standard C++ string class
  6. //
  7. //  This class uses a technique called "copy-on-write".
  8. //  Multiple instances of a string can refer to the same piece of data
  9. //  so long as it is in a "readonly" situation.  If a string writes to
  10. //  the data, then a copy is automatically made if more than one string
  11. //  is referring to it.
  12. //
  13. //----------------------------------------------------------------------------
  14. #if !defined(SERVICES_PRIVATE_CSTRING_H)
  15. #define SERVICES_PRIVATE_CSTRING_H
  16.  
  17. #if !defined(SERVICES_REF_H)
  18. # include <services/ref.h>
  19. #endif
  20. #if !defined(SERVICES_EXCEPT_H)
  21. # include <services/except.h>
  22. #endif
  23. #if !defined(CLASSLIB_STDTEMPL_H)
  24. # include <classlib/stdtempl.h>
  25. #endif
  26. #if !defined(WINSYS_WSYSINC_H)
  27. # include <winsys/wsysinc.h>
  28. #endif
  29. #include <string.h>
  30. #include <ctype.h>
  31. #include <stddef.h>
  32.  
  33. class _EXPCLASS string;
  34. class _EXPCLASS TRegexp;
  35. class _EXPCLASS TSubString;
  36. class _EXPCLASS TStringRef;
  37. class _EXPCLASS istream;
  38. class _EXPCLASS ostream;
  39.  
  40. /*------------------------------------------------------------------------*/
  41. /*                                                                        */
  42. /*  Since inline functions that use throw specifiers                      */
  43. /*  currently end up rather large, we don't use throw                     */
  44. /*  specifiers on them unless you #define USE_THROW_SPECIFIERS.           */
  45. /*                                                                        */
  46. /*------------------------------------------------------------------------*/
  47.  
  48. #if defined( USE_THROW_SPECIFIERS ) && !defined(BI_NO_THROWSPEC)
  49. #define THROW_NONE                  throw()
  50. #define THROW_XALLOC                throw(xalloc)
  51. #define THROW_OUTOFRANGE            throw( string::outofrange )
  52. #define THROW_XALLOC_LENGTHERROR    throw( xalloc, string::lengtherror )
  53. #define THROW_XALLOC_OUTOFRANGE     throw( xalloc, string::outofrange )
  54. #define THROW_XALLOC_RANGE_LENGTH   \
  55.         throw( xalloc, string::lengtherror, string::outofrange )
  56. #else
  57. #define THROW_NONE
  58. #define THROW_XALLOC
  59. #define THROW_OUTOFRANGE
  60. #define THROW_XALLOC_LENGTHERROR
  61. #define THROW_XALLOC_OUTOFRANGE
  62. #define THROW_XALLOC_RANGE_LENGTH
  63. #endif
  64.  
  65.  
  66. /*------------------------------------------------------------------------*/
  67. /*                                                                        */
  68. /*  string                                                                */
  69. /*                                                                        */
  70. /*------------------------------------------------------------------------*/
  71.  
  72. const size_t NPOS = size_t(-1);
  73.  
  74. class _EXPCLASS string
  75. {
  76.  
  77. public:
  78.  
  79.     //
  80.     // Exceptions
  81.     //
  82.     class outofrange : public xmsg
  83.     {
  84.     public:
  85.         _RTLENTRY outofrange();
  86.     };
  87.  
  88.     class lengtherror : public xmsg
  89.     {
  90.     public:
  91.         _RTLENTRY lengtherror();
  92.     };
  93.  
  94.     //
  95.     // Constructors
  96.     //
  97.  
  98.     _RTLENTRY string() THROW_XALLOC;
  99.  
  100.     _RTLENTRY string( const string _FAR &s ) THROW_XALLOC;
  101.     _RTLENTRY string( const string _FAR &s, size_t orig, size_t n = NPOS )
  102.         THROW_XALLOC;
  103.  
  104.     _RTLENTRY string( const char _FAR *cp ) THROW_XALLOC_LENGTHERROR;
  105.     _RTLENTRY string( const char _FAR *cp, size_t orig, size_t n = NPOS )
  106.         THROW_XALLOC_LENGTHERROR;
  107.  
  108.     _RTLENTRY string( char c ) THROW_XALLOC_LENGTHERROR;
  109.     _RTLENTRY string( char c, size_t n ) THROW_XALLOC_LENGTHERROR;
  110.  
  111.     _RTLENTRY string( signed char c ) THROW_XALLOC_LENGTHERROR;
  112.     _RTLENTRY string( signed char c, size_t n ) THROW_XALLOC_LENGTHERROR;
  113.  
  114.     _RTLENTRY string( unsigned char c ) THROW_XALLOC_LENGTHERROR;
  115.     _RTLENTRY string( unsigned char c, size_t n ) THROW_XALLOC_LENGTHERROR;
  116.  
  117.     // non-standard constructors
  118.     _RTLENTRY string( const TSubString _FAR &ss ) THROW_XALLOC;
  119.  
  120.     // Special far string ctors for small & medium model
  121. #if defined(BI_DATA_NEAR) && !defined(BI_APP_DLL)
  122.     _RTLENTRY string( const char __far *cp ) THROW_XALLOC_LENGTHERROR;
  123.     _RTLENTRY string( const char __far *cp, size_t orig, size_t n = NPOS )
  124.         THROW_XALLOC_LENGTHERROR;
  125. #endif
  126.  
  127.     // Ctor to make a string from a resource
  128. #if defined(BI_PLAT_MSW)
  129.     _RTLENTRY string( HINSTANCE instance, UINT id, int len = 255 )
  130.         THROW_XALLOC_LENGTHERROR;
  131. #endif
  132.  
  133.     //
  134.     // Destructor
  135.     //
  136.     _RTLENTRY ~string() THROW_NONE;
  137.  
  138.     //
  139.     // Assignment
  140.     //
  141.     string _FAR & _RTLENTRY operator = ( const string _FAR &s ) THROW_XALLOC;
  142.     string _FAR & _RTLENTRY assign( const string _FAR &s ) THROW_XALLOC;
  143.     string _FAR & _RTLENTRY assign( const string _FAR &s,
  144.                                     size_t orig,
  145.                                     size_t n = NPOS ) THROW_XALLOC;
  146.  
  147.     //
  148.     // Concatenation
  149.     //
  150.     string _FAR & _RTLENTRY operator += ( const string _FAR &s )
  151.         THROW_XALLOC_LENGTHERROR;
  152.     string _FAR & _RTLENTRY append( const string _FAR &s )
  153.         THROW_XALLOC_LENGTHERROR;
  154.     string _FAR & _RTLENTRY append( const string _FAR &s,
  155.                                     size_t orig,
  156.                                     size_t n = NPOS ) THROW_XALLOC_LENGTHERROR;
  157.  
  158.     string _FAR & _RTLENTRY operator += ( const char _FAR *cp )
  159.         THROW_XALLOC_LENGTHERROR;
  160.     friend string _RTLENTRY _FARFUNC operator + ( const string _FAR &s,
  161.                                                const char _FAR *cp )
  162.         THROW_XALLOC_LENGTHERROR;
  163.     string _FAR & _RTLENTRY append( const char _FAR *cp )
  164.         THROW_XALLOC_LENGTHERROR;
  165.     string _FAR & _RTLENTRY append( const char _FAR *cp,
  166.                                     size_t orig,
  167.                                     size_t n = NPOS ) THROW_XALLOC_LENGTHERROR;
  168.  
  169.     string _FAR & _RTLENTRY prepend( const string _FAR &s )
  170.         THROW_XALLOC_LENGTHERROR;
  171.     string _FAR & _RTLENTRY prepend( const string _FAR &s,
  172.                                      size_t orig,
  173.                                      size_t n = NPOS ) THROW_XALLOC_LENGTHERROR;
  174.     string _FAR & _RTLENTRY prepend( const char _FAR *cp )
  175.         THROW_XALLOC_LENGTHERROR;
  176.     string _FAR & _RTLENTRY prepend( const char _FAR *cp,
  177.                                      size_t orig,
  178.                                      size_t n = NPOS ) THROW_XALLOC_LENGTHERROR;
  179.  
  180.     //
  181.     // Comparison
  182.     //
  183.     int _RTLENTRY compare(const string _FAR &s) const THROW_NONE;
  184.     int _RTLENTRY compare(const string _FAR &s,
  185.                           size_t orig,
  186.                           size_t n = NPOS ) const THROW_NONE;
  187.  
  188.     friend int _RTLENTRY operator == ( const string _FAR &s1, const string _FAR &s2 )
  189.         THROW_NONE;
  190.  
  191.     friend int _RTLENTRY operator != ( const string _FAR &s1, const string _FAR &s2 )
  192.         THROW_NONE;
  193.  
  194.     friend int _RTLENTRY operator == ( const string _FAR &s, const char _FAR *cp )
  195.         THROW_NONE;
  196.     friend int _RTLENTRY operator == ( const char _FAR *cp, const string _FAR &s )
  197.         THROW_NONE;
  198.  
  199.     friend int _RTLENTRY operator != ( const string _FAR &s, const char _FAR *cp )
  200.         THROW_NONE;
  201.     friend int _RTLENTRY operator != ( const char _FAR *cp, const string _FAR &s )
  202.         THROW_NONE;
  203.  
  204.     friend int _RTLENTRY operator <  ( const string _FAR &s1, const string _FAR &s2 )
  205.         THROW_NONE;
  206.     friend int _RTLENTRY operator <  ( const string _FAR &s, const char _FAR *cp )
  207.         THROW_NONE;
  208.     friend int _RTLENTRY operator <  ( const char _FAR *cp, const string _FAR &s )
  209.         THROW_NONE;
  210.  
  211.     friend int _RTLENTRY operator <= ( const string _FAR &s1, const string _FAR &s2 )
  212.         THROW_NONE;
  213.     friend int _RTLENTRY operator <= ( const string _FAR &s, const char _FAR *cp )
  214.         THROW_NONE;
  215.     friend int _RTLENTRY operator <= ( const char _FAR *cp, const string _FAR &s )
  216.         THROW_NONE;
  217.  
  218.     friend int _RTLENTRY operator >  ( const string _FAR &s1, const string _FAR &s2 )
  219.         THROW_NONE;
  220.     friend int _RTLENTRY operator >  ( const string _FAR &s, const char _FAR *cp )
  221.         THROW_NONE;
  222.     friend int _RTLENTRY operator >  ( const char _FAR *cp, const string _FAR &s )
  223.         THROW_NONE;
  224.  
  225.     friend int _RTLENTRY operator >= ( const string _FAR &s1, const string _FAR &s2 )
  226.         THROW_NONE;
  227.     friend int _RTLENTRY operator >= ( const string _FAR &s, const char _FAR *cp )
  228.         THROW_NONE;
  229.     friend int _RTLENTRY operator >= ( const char _FAR *cp, const string _FAR &s )
  230.         THROW_NONE;
  231.  
  232.     //
  233.     // Insertion at some position
  234.     //
  235.     string _FAR & _RTLENTRY insert( size_t pos, const string _FAR &s )
  236.         THROW_XALLOC_RANGE_LENGTH;
  237.     string _FAR & _RTLENTRY insert( size_t pos,
  238.                                     const string _FAR &s,
  239.                                     size_t orig,
  240.                                     size_t n = NPOS ) THROW_XALLOC_RANGE_LENGTH;
  241.  
  242.     //
  243.     // Removal
  244.     //
  245.     string _FAR & _RTLENTRY remove( size_t pos ) THROW_XALLOC_OUTOFRANGE;
  246.     string _FAR & _RTLENTRY remove( size_t pos, size_t n )
  247.         THROW_XALLOC_OUTOFRANGE;
  248.  
  249.     //
  250.     // Replacement at some position
  251.     //
  252.     string _FAR & _RTLENTRY replace( size_t pos, size_t n, const string _FAR &s )
  253.         THROW_XALLOC_RANGE_LENGTH;
  254.     string _FAR & _RTLENTRY replace( size_t pos,
  255.                                      size_t n1,
  256.                                      const string _FAR &s,
  257.                                      size_t orig,
  258.                                      size_t n2 = NPOS ) THROW_XALLOC_RANGE_LENGTH;
  259.  
  260.     //
  261.     // Subscripting
  262.     //
  263.     char _RTLENTRY get_at( size_t pos ) const THROW_OUTOFRANGE;
  264.     void _RTLENTRY put_at( size_t pos, char c ) THROW_OUTOFRANGE;
  265.  
  266.     char _FAR & _RTLENTRY operator[]( size_t pos ) THROW_OUTOFRANGE;
  267.     char _FAR & _RTLENTRY operator()( size_t pos ) THROW_OUTOFRANGE;
  268.     TSubString _RTLENTRY operator()( size_t start, size_t len ) THROW_NONE;
  269.     TSubString _RTLENTRY operator()( const TRegexp _FAR &re ) THROW_NONE;
  270.     TSubString _RTLENTRY operator()( const TRegexp _FAR &re, size_t start ) THROW_NONE;
  271.  
  272.     char _RTLENTRY operator[]( size_t pos ) const THROW_OUTOFRANGE;
  273.     char _RTLENTRY operator()( size_t pos ) const THROW_OUTOFRANGE;
  274.     const TSubString _RTLENTRY operator()( size_t start, size_t len ) const THROW_NONE;
  275.     const TSubString _RTLENTRY operator()( const TRegexp _FAR &pat ) const THROW_NONE;
  276.     const TSubString _RTLENTRY operator()( const TRegexp _FAR &pat, size_t start )
  277.         const THROW_NONE;
  278.  
  279.     //
  280.     // Searching
  281.     //
  282.     size_t _RTLENTRY find( const string _FAR &s ) const THROW_NONE;
  283.     size_t _RTLENTRY find( const string _FAR &s, size_t pos ) const THROW_NONE;
  284.     size_t _RTLENTRY rfind( const string _FAR &s ) const THROW_NONE;
  285.     size_t _RTLENTRY rfind( const string _FAR &s, size_t pos ) const THROW_NONE;
  286.  
  287.     int _RTLENTRY contains( const char _FAR *pat ) const THROW_NONE;
  288.     int _RTLENTRY contains(const string _FAR &s) const THROW_NONE;
  289.     size_t _RTLENTRY find( const TRegexp _FAR &pat, size_t i = 0 ) const THROW_NONE;
  290.     size_t _RTLENTRY find( const TRegexp _FAR &pat, size_t _FAR *ext, size_t i = 0 )
  291.         const THROW_NONE;
  292.  
  293.     //
  294.     // Substring
  295.     //
  296.     string _RTLENTRY substr( size_t pos ) const
  297.         THROW_XALLOC_OUTOFRANGE;
  298.     string _RTLENTRY substr( size_t pos, size_t n ) const
  299.         THROW_XALLOC_OUTOFRANGE;
  300.  
  301.     TSubString _RTLENTRY substring( const char _FAR *cp ) THROW_NONE;
  302.     const TSubString _RTLENTRY substring( const char _FAR *cp )
  303.         const THROW_NONE;
  304.     TSubString _RTLENTRY substring( const char _FAR *cp, size_t start ) THROW_NONE;
  305.     const TSubString _RTLENTRY substring( const char _FAR *cp, size_t start )
  306.         const THROW_NONE;
  307.  
  308.     //
  309.     // Character set searching
  310.     //
  311.     size_t _RTLENTRY find_first_of( const string _FAR &s ) const THROW_NONE;
  312.     size_t _RTLENTRY find_first_of( const string _FAR &s, size_t pos ) const THROW_NONE;
  313.     size_t _RTLENTRY find_first_not_of( const string _FAR &s ) const THROW_NONE;
  314.     size_t _RTLENTRY find_first_not_of( const string _FAR &s, size_t pos )
  315.         const THROW_NONE;
  316.     size_t _RTLENTRY find_last_of( const string _FAR &s ) const THROW_NONE;
  317.     size_t _RTLENTRY find_last_of( const string _FAR &s, size_t pos ) const THROW_NONE;
  318.     size_t _RTLENTRY find_last_not_of( const string _FAR &s ) const THROW_NONE;
  319.     size_t _RTLENTRY find_last_not_of( const string _FAR &s, size_t pos )
  320.         const THROW_NONE;
  321.  
  322.     //
  323.     // Miscellaneous
  324.     //
  325.     size_t _RTLENTRY length() const THROW_NONE;
  326.     size_t _RTLENTRY copy( char _FAR *cb, size_t n ) THROW_OUTOFRANGE;
  327.     size_t _RTLENTRY copy( char _FAR *cb, size_t n, size_t pos ) THROW_OUTOFRANGE;
  328.     const char _FAR * _RTLENTRY c_str() const THROW_XALLOC;
  329.     size_t _RTLENTRY reserve() const THROW_NONE;
  330.     void _RTLENTRY reserve( size_t ic ) THROW_XALLOC_OUTOFRANGE;
  331.  
  332.     string _RTLENTRY copy() const THROW_XALLOC;    // Distinct copy of self.
  333.  
  334.  
  335.     // Static member functions:
  336.     static int _RTLENTRY set_case_sensitive( int tf = 1 );
  337.     static int _RTLENTRY set_paranoid_check( int ck = 1 );
  338.     static int _RTLENTRY skip_whitespace( int sk = 1 );
  339.     static size_t _RTLENTRY initial_capacity( size_t ic = 63 );
  340.     static size_t _RTLENTRY resize_increment( size_t ri = 64 );
  341.     static size_t _RTLENTRY max_waste( size_t mw = 63 );
  342.  
  343.     static int _RTLENTRY get_case_sensitive_flag();
  344.     static int _RTLENTRY get_paranoid_check_flag();
  345.     static int _RTLENTRY get_skip_whitespace_flag();
  346.     static size_t _RTLENTRY get_initial_capacity();
  347.     static size_t _RTLENTRY get_resize_increment();
  348.     static size_t _RTLENTRY get_max_waste();
  349.  
  350.     enum StripType { Leading, Trailing, Both };
  351.  
  352.     // Non-static member functions:
  353.     unsigned _RTLENTRY hash() const;
  354.     int      _RTLENTRY is_null() const;
  355.     istream _FAR & _RTLENTRY read_file( istream _FAR &is );
  356.     istream _FAR & _RTLENTRY read_string( istream _FAR &is );
  357.     istream _FAR & _RTLENTRY read_line( istream _FAR &is );
  358.     istream _FAR & _RTLENTRY read_to_delim( istream _FAR &is, char delim = '\n' );
  359.     istream _FAR & _RTLENTRY read_token( istream _FAR &is );
  360.     void       _RTLENTRY resize( size_t m );
  361.     TSubString _RTLENTRY strip( StripType s = Trailing, char c = ' ' );
  362.     void       _RTLENTRY to_lower();
  363.     void       _RTLENTRY to_upper();
  364.  
  365.     #if defined( _Windows )
  366.     void _RTLENTRY ansi_to_oem() THROW_NONE;
  367.     void _RTLENTRY oem_to_ansi() THROW_NONE;
  368.     #endif
  369.  
  370. protected:
  371.  
  372.     int  _RTLENTRY valid_element( size_t pos ) const THROW_NONE;
  373.     int  _RTLENTRY valid_index( size_t pos ) const THROW_NONE;
  374.  
  375.     void _RTLENTRY assert_element( size_t pos ) const THROW_OUTOFRANGE;
  376.     void _RTLENTRY assert_index( size_t pos ) const THROW_OUTOFRANGE;
  377.  
  378.     _RTLENTRY string( const string _FAR &s, const char _FAR *cb );
  379.     void _RTLENTRY cow();
  380.  
  381. private:
  382.  
  383.     TStringRef _FAR *p;
  384.  
  385.     static int case_sensitive;
  386.     static int paranoid_check;
  387.     static int skip_white;
  388.     static size_t initial_capac;
  389.     static size_t resize_inc;
  390.     static size_t freeboard;
  391.  
  392. private:
  393.  
  394.     friend class _EXPCLASS TSubString;
  395.     friend class _EXPCLASS TStringRef;
  396.  
  397.     void _RTLENTRY clone();
  398.     size_t _RTLENTRY find_case_index( const char _FAR *cb,
  399.                             size_t start,
  400.                             size_t _FAR &patl) const;
  401.     size_t _RTLENTRY rfind_case_index( const char _FAR *cb,
  402.                              size_t start,
  403.                              size_t _FAR &patl) const;
  404.     size_t _RTLENTRY find_index(const char _FAR *,
  405.                       size_t start,
  406.                       size_t _FAR & patl) const;
  407.     size_t _RTLENTRY rfind_index(const char _FAR *,
  408.                        size_t start,
  409.                        size_t _FAR & patl) const;
  410.     unsigned _RTLENTRY hash_case() const;
  411.  
  412. };
  413.  
  414. #if defined( BI_OLDNAMES )
  415. #define BI_String string
  416. #endif
  417.  
  418. /*------------------------------------------------------------------------*/
  419. /*                                                                        */
  420. /*  Related global functions                                              */
  421. /*                                                                        */
  422. /*------------------------------------------------------------------------*/
  423.  
  424. istream _FAR &
  425. _RTLENTRY _FARFUNC operator >> ( istream _FAR &is, string _FAR &s );
  426.  
  427. ostream _FAR &
  428. _RTLENTRY _FARFUNC operator << ( ostream _FAR &os, const string _FAR &s );
  429.  
  430. istream _FAR &
  431. _RTLENTRY _FARFUNC getline( istream _FAR &is, string _FAR &s );
  432.  
  433. istream _FAR &
  434. _RTLENTRY _FARFUNC getline( istream _FAR &is, string _FAR &s, char c );
  435.  
  436. string _RTLENTRY _FARFUNC to_lower( const string _FAR &s ) THROW_NONE;
  437. string _RTLENTRY _FARFUNC to_upper( const string _FAR &s ) THROW_NONE;
  438. string _RTLENTRY _FARFUNC operator + ( const char _FAR *cp,
  439.                                     const string _FAR & s)
  440.                                     THROW_XALLOC_LENGTHERROR;
  441. string _RTLENTRY _FARFUNC operator + ( const string _FAR &s1,
  442.                                     const string _FAR &s2 )
  443.                                     THROW_XALLOC_LENGTHERROR;
  444.  
  445. /*------------------------------------------------------------------------*/
  446. /*                                                                        */
  447. /*  TStringRef                                                            */
  448. /*                                                                        */
  449. /*  This is the dynamically allocated part of a string.                   */
  450. /*  It maintains a reference count.                                       */
  451. /*  There are no public member functions.                                 */
  452. /*                                                                        */
  453. /*------------------------------------------------------------------------*/
  454.  
  455. class _EXPCLASS TStringRef : public TReference
  456. {
  457.  
  458.     friend class _EXPCLASS string;
  459.     friend class _EXPCLASS TSubString;
  460.  
  461.     //
  462.     // Data
  463.     //
  464.     char _FAR *array;
  465.     size_t nchars;
  466.     size_t capacity;
  467.  
  468.     //
  469.     // State flags
  470.     //
  471.     enum {
  472.         MemReserved = 1     // indicates that reserve() has been
  473.                             // called on this string
  474.         };
  475.     unsigned flags;
  476.  
  477.     //
  478.     // Constructors
  479.     //
  480.     _RTLENTRY TStringRef( char c, size_t n );
  481.     _RTLENTRY TStringRef( const char _FAR *str1, size_t count1,
  482.                 const char _FAR *str2, size_t count2,
  483.                 size_t extra );
  484.  
  485.     // Special far TStringRef ctor for small data models
  486. #if defined(BI_DATA_NEAR) && !defined(BI_APP_DLL)
  487.     _RTLENTRY TStringRef( const char __far*, size_t n = NPOS );
  488. #endif
  489.  
  490.     //
  491.     // Ctor to make a TStringRef from a resource
  492.     //
  493. #if defined(BI_PLAT_MSW)
  494.     _RTLENTRY TStringRef( HINSTANCE instance, UINT id, int len = 255 )
  495.          THROW_XALLOC_LENGTHERROR;
  496. #endif
  497.  
  498.     //
  499.     // Destructor
  500.     //
  501.     _RTLENTRY ~TStringRef() THROW_NONE;
  502.  
  503.     //
  504.     // Miscellaneous
  505.     //
  506.     void _RTLENTRY reserve( size_t ic ) THROW_XALLOC_OUTOFRANGE;
  507.     void _RTLENTRY check_freeboard() THROW_NONE;
  508.     void _RTLENTRY grow_to( size_t n ) THROW_XALLOC_LENGTHERROR;
  509.     void _RTLENTRY read_to_delim( istream _FAR &is, char delim ) THROW_XALLOC;
  510.     void _RTLENTRY read_token( istream _FAR &is ) THROW_XALLOC;
  511.     static size_t _RTLENTRY round_capacity( size_t cap ) THROW_NONE;
  512.     void _RTLENTRY splice( size_t start, size_t extent,
  513.                  const char _FAR *cp, size_t n )
  514.         THROW_XALLOC_LENGTHERROR;
  515.  
  516. };
  517.  
  518. #if defined( BI_OLDNAMES )
  519. #define BI_StringRef TStringRef
  520. #endif
  521.  
  522. /*------------------------------------------------------------------------*/
  523. /*                                                                        */
  524. /*  TSubString                                                            */
  525. /*                                                                        */
  526. /*  The TSubString class allows selected elements to be addressed.        */
  527. /*  There are no public constructors.                                     */
  528. /*                                                                        */
  529. /*------------------------------------------------------------------------*/
  530.  
  531. class _EXPCLASS TSubString
  532. {
  533.  
  534. public:
  535.  
  536.     //
  537.     // Assignment
  538.     //
  539.     TSubString _FAR & _RTLENTRY operator = ( const string _FAR &s ) THROW_NONE;
  540.  
  541.     //
  542.     // Comparison
  543.     //
  544.     int _RTLENTRY operator == ( const char _FAR *cp ) const THROW_NONE;
  545.     int _RTLENTRY operator == ( const string _FAR &s ) const THROW_NONE;
  546.     int _RTLENTRY operator != ( const char _FAR *cp ) const THROW_NONE;
  547.     int _RTLENTRY operator != ( const string _FAR & str ) const THROW_NONE;
  548.  
  549.     //
  550.     // Subscripting
  551.     //
  552.     char _RTLENTRY get_at( size_t pos ) const THROW_OUTOFRANGE;
  553.     void _RTLENTRY put_at( size_t pos, char c ) THROW_OUTOFRANGE;
  554.  
  555.     char _FAR & _RTLENTRY operator[]( size_t pos ) THROW_OUTOFRANGE;
  556.     char _FAR & _RTLENTRY operator()( size_t pos ) THROW_OUTOFRANGE;
  557.     char _RTLENTRY operator[]( size_t pos ) const THROW_OUTOFRANGE;
  558.     char _RTLENTRY operator()( size_t pos ) const THROW_OUTOFRANGE;
  559.     size_t _RTLENTRY length() const THROW_NONE;
  560.     int _RTLENTRY start() const THROW_NONE;
  561.     void _RTLENTRY to_lower() THROW_NONE;
  562.     void _RTLENTRY to_upper() THROW_NONE;
  563.  
  564.     //
  565.     // Detecting empty strings
  566.     //
  567.     int _RTLENTRY is_null() const THROW_NONE;
  568.     int _RTLENTRY operator!() const THROW_NONE;
  569.  
  570. protected:
  571.  
  572.     void _RTLENTRY assert_element( size_t pos ) const THROW_OUTOFRANGE;
  573.     int _RTLENTRY valid_element( size_t pos ) const;
  574.  
  575. private:
  576.  
  577.     friend class _EXPCLASS string;
  578.  
  579.     //
  580.     // Data
  581.     //
  582.     string _FAR *s;
  583.     size_t begin;
  584.     size_t extent;
  585.  
  586.     //
  587.     // Constructor
  588.     //
  589.     _RTLENTRY TSubString( const string _FAR *cp, size_t start, size_t len );
  590.  
  591. };
  592.  
  593. #if defined( BI_OLDNAMES )
  594. #define BI_SubString TSubString
  595. #endif
  596.  
  597. /*------------------------------------------------------------------------*/
  598. /*                                                                        */
  599. /*  string inlines                                                        */
  600. /*                                                                        */
  601. /*------------------------------------------------------------------------*/
  602.  
  603. inline _RTLENTRY string::outofrange::outofrange() :
  604.     xmsg( "String reference out of range" )
  605. {
  606. }
  607.  
  608. inline _RTLENTRY string::lengtherror::lengtherror() :
  609.     xmsg( "String length error" )
  610. {
  611. }
  612.  
  613. inline _RTLENTRY string::string( char c ) THROW_XALLOC_LENGTHERROR
  614. {
  615.     p = new TStringRef(c,1);
  616. }
  617.  
  618. inline _RTLENTRY string::string( char c, size_t n ) THROW_XALLOC_LENGTHERROR
  619. {
  620.     p = new TStringRef(c,n);
  621. }
  622.  
  623. inline _RTLENTRY string::string( signed char c ) THROW_XALLOC_LENGTHERROR
  624. {
  625.     p = new TStringRef(c,1);
  626. }
  627.  
  628. inline _RTLENTRY string::string( signed char c, size_t n ) THROW_XALLOC_LENGTHERROR
  629. {
  630.     p = new TStringRef(c,n);
  631. }
  632.  
  633. inline _RTLENTRY string::string( unsigned char c ) THROW_XALLOC_LENGTHERROR
  634. {
  635.     p = new TStringRef(c,1);
  636. }
  637.  
  638. inline _RTLENTRY string::string( unsigned char c, size_t n ) THROW_XALLOC_LENGTHERROR
  639. {
  640.     p = new TStringRef(c,n);
  641. }
  642.  
  643. #if (defined(__TINY__)|| defined(__SMALL__)|| defined(__MEDIUM__)) && !defined(__DLL__)
  644. // Far string ctors make a near string from a far string
  645.  
  646. inline _RTLENTRY string::string( const char __far *cp ) THROW_XALLOC_LENGTHERROR
  647. {
  648.     p = new TStringRef(cp);
  649. }
  650.  
  651. #endif
  652.  
  653. inline string _FAR & _RTLENTRY string::operator = ( const string _FAR &s )
  654.     THROW_NONE
  655. {
  656.     return assign( s, 0, NPOS );
  657. }
  658.  
  659. inline string _FAR & _RTLENTRY string::assign( const string _FAR &s )
  660.     THROW_NONE
  661. {
  662.     return assign( s, 0, NPOS );
  663. }
  664.  
  665. inline string _FAR & _RTLENTRY string::operator += ( const string _FAR &s )
  666.     THROW_XALLOC_LENGTHERROR
  667. {
  668.     return append( s, 0, NPOS );
  669. }
  670.  
  671. inline string _FAR & _RTLENTRY string::append( const string _FAR &s )
  672.     THROW_XALLOC_LENGTHERROR
  673. {
  674.     return append(s, 0, NPOS);
  675. }
  676.  
  677. inline string _FAR & _RTLENTRY string::prepend( const char _FAR *cp )
  678.     THROW_XALLOC_LENGTHERROR
  679. {
  680.     return prepend( cp, 0, strlen(cp) );
  681. }
  682.  
  683. inline int _RTLENTRY operator == ( const string _FAR &s1, const string _FAR &s2 )
  684.     THROW_NONE
  685. {
  686.     return s1.compare( s2 ) == 0;
  687. }
  688.  
  689. inline int _RTLENTRY operator != ( const string _FAR &s1, const string _FAR &s2 )
  690.     THROW_NONE
  691. {
  692.     return !(s1==s2);
  693. }
  694.  
  695. inline string _FAR & _RTLENTRY string::remove( size_t pos )
  696.     THROW_XALLOC_OUTOFRANGE
  697. {
  698.     return remove( pos, length() );
  699. }
  700.  
  701. inline string _FAR & _RTLENTRY string::replace( size_t pos,
  702.                                      size_t n,
  703.                                      const string _FAR &s )
  704.     THROW_XALLOC_RANGE_LENGTH
  705. {
  706.     return replace( pos, n, s, 0, NPOS );
  707. }
  708.  
  709. inline char _RTLENTRY string::get_at( size_t pos ) const THROW_OUTOFRANGE
  710. {
  711.     return (*this)[pos];
  712. }
  713.  
  714. inline void _RTLENTRY string::put_at( size_t pos, char c ) THROW_OUTOFRANGE
  715. {
  716.     (*this)[pos] = c;
  717. }
  718.  
  719. inline char _FAR & _RTLENTRY string::operator[]( size_t pos ) THROW_OUTOFRANGE
  720. {
  721.     return (*this)(pos);    // use operator()
  722. }
  723.  
  724. inline TSubString _RTLENTRY string::operator()( size_t start, size_t len ) THROW_NONE
  725. {
  726.     return TSubString( this, start, len );
  727. }
  728.  
  729. inline size_t _RTLENTRY string::find( const string _FAR &s ) const THROW_NONE
  730. {
  731.     return find( s, 0 );
  732. }
  733.  
  734. inline size_t _RTLENTRY string::rfind( const string _FAR &s ) const THROW_NONE
  735. {
  736.     return rfind( s, length() );
  737. }
  738.  
  739. inline size_t _RTLENTRY string::length() const THROW_NONE
  740. {
  741.     return p->nchars;
  742. }
  743.  
  744. inline const char _FAR * _RTLENTRY string::c_str() const THROW_NONE
  745. {
  746.     return p->array;
  747. }
  748.  
  749. inline size_t _RTLENTRY string::reserve() const THROW_NONE
  750. {
  751.     return p->capacity;
  752. }
  753.  
  754. inline void _RTLENTRY string::cow()
  755. {
  756.     if( p->References() > 1 )
  757.         clone();
  758. }
  759.  
  760. inline string _FAR & _RTLENTRY string::operator += ( const char _FAR *cp )
  761.     THROW_XALLOC_LENGTHERROR
  762. {
  763.     return append( cp, 0, strlen(cp) );
  764. }
  765.  
  766. inline string _FAR & _RTLENTRY string::prepend( const string _FAR &s )
  767.     THROW_XALLOC_LENGTHERROR
  768. {
  769.     return prepend( s.c_str() );
  770. }
  771.  
  772. inline string _FAR & _RTLENTRY string::prepend( const string _FAR &s,
  773.                                                 size_t orig,
  774.                                                 size_t n ) THROW_XALLOC_LENGTHERROR
  775. {
  776.     return prepend( s.c_str(), orig, n );
  777. }
  778.  
  779. inline int _RTLENTRY operator == ( const string _FAR &s1, const char _FAR *s2 ) THROW_NONE
  780. {
  781.     return s1.compare(s2) == 0;
  782. }
  783.  
  784. inline int _RTLENTRY operator == ( const char _FAR *cp, const string _FAR &s ) THROW_NONE
  785. {
  786.     return string(cp).compare(s) == 0;
  787. }
  788.  
  789. inline int _RTLENTRY operator != ( const string _FAR &s, const char _FAR *cp ) THROW_NONE
  790. {
  791.     return !(s==cp);
  792. }
  793.  
  794. inline int _RTLENTRY operator != ( const char _FAR *cp, const string _FAR &s ) THROW_NONE
  795. {
  796.     return !(cp==s);
  797. }
  798.  
  799. inline int _RTLENTRY operator <  ( const string _FAR &s1, const string _FAR &s2 )
  800.     THROW_NONE
  801. {
  802.     return s1.compare(s2) < 0;
  803. }
  804.  
  805. inline int _RTLENTRY operator <  ( const string _FAR &s1, const char _FAR *s2 ) THROW_NONE
  806. {
  807.     return s1.compare(s2) < 0;
  808. }
  809.  
  810. inline int _RTLENTRY operator <  ( const char _FAR *cp, const string _FAR &s ) THROW_NONE
  811. {
  812.     return string(cp).compare(s) < 0;
  813. }
  814.  
  815. inline int _RTLENTRY operator <= ( const string _FAR &s1, const string _FAR &s2 )
  816.     THROW_NONE
  817. {
  818.     return s1.compare(s2) <= 0;
  819. }
  820.  
  821. inline int _RTLENTRY operator <= ( const string _FAR &s, const char _FAR *cp ) THROW_NONE
  822. {
  823.     return s.compare(string(cp)) <= 0;
  824. }
  825.  
  826. inline int _RTLENTRY operator <= ( const char _FAR *cp, const string _FAR &s ) THROW_NONE
  827. {
  828.     return string(cp).compare(s) <= 0;
  829. }
  830.  
  831. inline int _RTLENTRY operator >  ( const string _FAR &s1, const string _FAR &s2 )
  832.     THROW_NONE
  833. {
  834.     return s1.compare(s2) > 0;
  835. }
  836.  
  837. inline int _RTLENTRY operator >  ( const string _FAR &s, const char _FAR *cp ) THROW_NONE
  838. {
  839.     return s.compare(cp) > 0;
  840. }
  841.  
  842. inline int _RTLENTRY operator >  ( const char _FAR *cp, const string _FAR &s ) THROW_NONE
  843. {
  844.     return string(cp).compare(s) > 0;
  845. }
  846.  
  847. inline int _RTLENTRY operator >= ( const string _FAR &s1, const string _FAR &s2 )
  848.     THROW_NONE
  849. {
  850.     return s1.compare(s2) >= 0;
  851. }
  852.  
  853. inline int _RTLENTRY operator >= ( const string _FAR &s, const char _FAR *cp ) THROW_NONE
  854. {
  855.     return s.compare(cp) >= 0;
  856. }
  857.  
  858. inline int _RTLENTRY operator >= ( const char _FAR *cp, const string _FAR &s ) THROW_NONE
  859. {
  860.     return string(cp).compare(s) >= 0;
  861. }
  862.  
  863. inline char _RTLENTRY string::operator[]( size_t pos ) const THROW_OUTOFRANGE
  864. {
  865.     assert_element(pos);
  866.     return p->array[pos];
  867. }
  868.  
  869. inline char _RTLENTRY string::operator()( size_t pos ) const THROW_OUTOFRANGE
  870. {
  871. #if defined( BOUNDS_CHECK )
  872.     assert_element(pos);
  873. #endif
  874.     return p->array[pos];
  875. }
  876.  
  877. inline int _RTLENTRY string::contains( const string _FAR &s ) const THROW_NONE
  878. {
  879.     return contains( s.c_str() );
  880. }
  881.  
  882. inline TSubString _RTLENTRY string::substring( const char _FAR *cp ) THROW_NONE
  883. {
  884.     return substring( cp, 0 );
  885. }
  886.  
  887. inline const TSubString _RTLENTRY string::substring( const char _FAR *cp ) const
  888.     THROW_NONE
  889. {
  890.     return substring( cp, 0 );
  891. }
  892.  
  893. inline size_t _RTLENTRY string::find_first_of( const string _FAR &s ) const THROW_NONE
  894. {
  895.     return find_first_of( s, 0 );
  896. }
  897.  
  898. inline size_t _RTLENTRY string::find_first_not_of( const string _FAR &s ) const THROW_NONE
  899. {
  900.     return find_first_not_of( s, 0 );
  901. }
  902.  
  903. inline size_t _RTLENTRY string::find_last_of( const string _FAR &s ) const THROW_NONE
  904. {
  905.     return find_last_of( s, NPOS );
  906. }
  907.  
  908. inline size_t _RTLENTRY string::find_last_not_of( const string _FAR &s ) const THROW_NONE
  909. {
  910.     return find_last_not_of( s, NPOS );
  911. }
  912.  
  913. inline int _RTLENTRY string::get_case_sensitive_flag()
  914. {
  915.     return case_sensitive;
  916. }
  917.  
  918. inline int _RTLENTRY string::get_paranoid_check_flag()
  919. {
  920.     return paranoid_check;
  921. }
  922.  
  923. inline int _RTLENTRY string::get_skip_whitespace_flag()
  924. {
  925.     return skip_white;
  926. }
  927.  
  928. inline size_t _RTLENTRY string::get_initial_capacity()
  929. {
  930.     return initial_capac;
  931. }
  932.  
  933. inline size_t _RTLENTRY string::get_resize_increment()
  934. {
  935.     return resize_inc;
  936. }
  937.  
  938. inline size_t _RTLENTRY string::get_max_waste()
  939. {
  940.     return freeboard;
  941. }
  942.  
  943. inline int _RTLENTRY string::is_null() const
  944. {
  945.     return *p->array==0;
  946. }
  947.  
  948. #if defined( _Windows )
  949. inline void _RTLENTRY string::ansi_to_oem() THROW_NONE
  950. {
  951.     ::AnsiToOem( p->array, p->array );
  952. }
  953.  
  954. inline void _RTLENTRY string::oem_to_ansi() THROW_NONE
  955. {
  956.     ::OemToAnsi( p->array, p->array );
  957. }
  958. #endif
  959.  
  960. // Check to make sure a string index refers to a valid element
  961. inline int _RTLENTRY string::valid_element( size_t n ) const THROW_NONE
  962. {
  963.     return n < length();
  964. }
  965.  
  966. // Check to make sure a string index is in range
  967. inline int _RTLENTRY string::valid_index( size_t n ) const THROW_NONE
  968. {
  969.     return n <= length();
  970. }
  971.  
  972. // Constructor for internal use only
  973. inline _RTLENTRY string::string( const string _FAR &s, const char _FAR *cp )
  974. {
  975.     p = new TStringRef( s.c_str(), s.length(), cp, cp?strlen(cp):0, 0 );
  976. }
  977.  
  978. inline string _RTLENTRY operator + ( const string _FAR &s,
  979.                                   const char _FAR *cp )
  980.     THROW_XALLOC_LENGTHERROR
  981. {
  982.     return string(s,cp);
  983. }
  984.  
  985. inline string _RTLENTRY operator + ( const string _FAR &s1,
  986.                                   const string _FAR &s2 )
  987.     THROW_XALLOC_LENGTHERROR
  988. {
  989.     return s1 + s2.c_str();
  990. }
  991.  
  992. /*------------------------------------------------------------------------*/
  993. /*                                                                        */
  994. /*  TSubString inlines                                                    */
  995. /*                                                                        */
  996. /*------------------------------------------------------------------------*/
  997.  
  998. inline int _RTLENTRY TSubString::operator == ( const string _FAR &s ) const THROW_NONE
  999. {
  1000.     return operator==(s.c_str());
  1001. }
  1002.  
  1003. inline int _RTLENTRY TSubString::operator != ( const char _FAR *cp ) const THROW_NONE
  1004. {
  1005.     return !operator==(cp);
  1006. }
  1007.  
  1008. inline int _RTLENTRY TSubString::operator != ( const string _FAR &s ) const THROW_NONE
  1009. {
  1010.     return !operator==(s.c_str());
  1011. }
  1012.  
  1013. inline char _RTLENTRY TSubString::get_at( size_t pos ) const THROW_OUTOFRANGE
  1014. {
  1015.     return (*this)[pos];
  1016. }
  1017.  
  1018. inline void _RTLENTRY TSubString::put_at( size_t pos, char c ) THROW_OUTOFRANGE
  1019. {
  1020.     (*this)[pos] = c;
  1021. }
  1022.  
  1023. inline char _FAR & _RTLENTRY TSubString::operator[]( size_t pos ) THROW_OUTOFRANGE
  1024. {
  1025.     return (*this)(pos);    // use operator()
  1026. }
  1027.  
  1028. inline char _RTLENTRY TSubString::operator[]( size_t pos ) const
  1029.     THROW_OUTOFRANGE
  1030. {
  1031.     assert_element(pos);
  1032.     return s->p->array[begin+pos];
  1033. }
  1034.  
  1035. inline char _RTLENTRY TSubString::operator()( size_t pos ) const
  1036.     THROW_OUTOFRANGE
  1037. {
  1038. #if defined( BOUNDS_CHECK )
  1039.     assert_element(pos);
  1040. #endif
  1041.     return s->p->array[begin+pos];
  1042. }
  1043.  
  1044. inline size_t _RTLENTRY TSubString::length() const THROW_NONE
  1045. {
  1046.     return extent;
  1047. }
  1048.  
  1049. inline int _RTLENTRY TSubString::start() const THROW_NONE
  1050. {
  1051.     return begin;
  1052. }
  1053.  
  1054. inline int _RTLENTRY TSubString::is_null() const THROW_NONE
  1055. {
  1056.     return begin == NPOS;
  1057. }
  1058.  
  1059. inline int _RTLENTRY TSubString::operator!() const THROW_NONE
  1060. {
  1061.     return begin == NPOS;
  1062. }
  1063.  
  1064. inline int _RTLENTRY TSubString::valid_element( size_t n ) const THROW_NONE
  1065. {
  1066.     return n < length();
  1067. }
  1068.  
  1069. // Private constructor
  1070. inline _RTLENTRY TSubString::TSubString(const string _FAR *sp,
  1071.                               size_t start,
  1072.                               size_t len ) :
  1073.     begin(start),
  1074.     extent(len),
  1075.     s((string _FAR *)sp)
  1076. {
  1077. }
  1078.  
  1079. inline TSubString _RTLENTRY string::operator()( const TRegexp _FAR & r ) THROW_NONE
  1080. {
  1081.     return (*this)(r,0);
  1082. }
  1083.  
  1084. inline const TSubString _RTLENTRY string::operator()( const TRegexp _FAR &r ) const THROW_NONE
  1085. {
  1086.     return (*this)(r,0);
  1087. }
  1088.  
  1089. #endif  // SERVICES_PRIVATE_CSTRING_H
  1090.